home *** CD-ROM | disk | FTP | other *** search
/ Aminet 4 / Aminet 4 - November 1994.iso / aminet / comm / term / term41source.lha / Extras / Source / term-Source.lha / SerialPanel.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-07-31  |  13.4 KB  |  599 lines
  1. /*
  2. **    SerialPanel.c
  3. **
  4. **    Editing panel for serial configuration
  5. **
  6. **    Copyright © 1990-1994 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. */
  9.  
  10. #include "termGlobal.h"
  11.  
  12. enum    {    GAD_BAUD=1000,GAD_DATABITS,GAD_PARITY,GAD_STOPBITS,GAD_HANDSHAKING,GAD_DUPLEX,GAD_BUFFERSIZE,GAD_BREAKLENGTH,
  13.         GAD_STRIP,GAD_HIGHSPEED,GAD_CHECK_CARRIER,GAD_SHARED,GAD_XON_XOFF,GAD_PASSTHROUGH,
  14.         GAD_DEVICE,GAD_SELECT,GAD_UNIT,GAD_QUANTUM,GAD_USE_OWNDEVUNIT,
  15.         GAD_USE,GAD_CANCEL,GAD_DEFAULT };
  16.  
  17. STATIC LONG Sizes[] =
  18. {
  19.     16,32,64,128,256,512,1024,2048,4096,8192,16384,32768,65536,131072,262144,524288
  20. };
  21.  
  22. STATIC LONG __saveds
  23. ShowBaud(struct Gadget *SomeGadget,WORD Level)
  24. {
  25.     return(BaudRates[Level]);
  26. }
  27.  
  28. STATIC LONG __saveds
  29. ShowSize(struct Gadget *SomeGadget,WORD Level)
  30. {
  31.     return(Sizes[Level]);
  32. }
  33.  
  34. STATIC LONG __saveds __asm
  35. RateHookFunc(register __a2 LONG Current,register __a1 LONG Command)
  36. {
  37.     LONG Index;
  38.  
  39.     if(Current < BaudRates[0])
  40.         Current = BaudRates[Index = 0];
  41.     else
  42.     {
  43.         if(Current > BaudRates[NumBaudRates - 1])
  44.             Current = BaudRates[Index = NumBaudRates - 1];
  45.         else
  46.         {
  47.             LONG i;
  48.  
  49.             Index = -1;
  50.  
  51.             for(i = 0 ; i < NumBaudRates ; i++)
  52.             {
  53.                 if(Current == BaudRates[i])
  54.                 {
  55.                     switch(Command)
  56.                     {
  57.                         case INCREMENTERMSG_DECREMENT:
  58.  
  59.                             if(i > 0)
  60.                                 return(BaudRates[i - 1]);
  61.                             else
  62.                                 return(Current);
  63.  
  64.                         case INCREMENTERMSG_INCREMENT:
  65.  
  66.                             if(i < NumBaudRates - 1)
  67.                                 return(BaudRates[i + 1]);
  68.                             else
  69.                                 return(Current);
  70.  
  71.                         default:
  72.  
  73.                             return(Current);
  74.                     }
  75.                 }
  76.             }
  77.  
  78.             if(Index == -1)
  79.             {
  80.                 if(Command == INCREMENTERMSG_DECREMENT)
  81.                 {
  82.                     for(i = 0 ; i < NumBaudRates ; i++)
  83.                     {
  84.                         if(BaudRates[i] <= Current)
  85.                             Index = i;
  86.                     }
  87.  
  88.                     if(BaudRates[Index] < Current || !Index)
  89.                         return(BaudRates[Index]);
  90.                     else
  91.                         return(BaudRates[Index - 1]);
  92.                 }
  93.                 else
  94.                 {
  95.                     for(i = NumBaudRates - 1 ; i >= 0 ; i--)
  96.                     {
  97.                         if(BaudRates[i] >= Current)
  98.                             Index = i;
  99.                     }
  100.  
  101.                     if(Command == INCREMENTERMSG_INITIAL)
  102.                     {
  103.                         if(Index == -1)
  104.                             return(Current);
  105.                         else
  106.                             return(BaudRates[Index]);
  107.                     }
  108.                     else
  109.                     {
  110.                         if(BaudRates[Index] > Current || Index == NumBaudRates - 1)
  111.                             return(BaudRates[Index]);
  112.                         else
  113.                             return(BaudRates[Index + 1]);
  114.                     }
  115.                 }
  116.             }
  117.         }
  118.     }
  119.  
  120.     if(Index == -1 || (Command != INCREMENTERMSG_DECREMENT && Command != INCREMENTERMSG_INCREMENT))
  121.         return(Current);
  122.     else
  123.     {
  124.         if(Command == INCREMENTERMSG_DECREMENT)
  125.         {
  126.             if(Index > 0)
  127.                 return(BaudRates[Index - 1]);
  128.             else
  129.                 return(BaudRates[Index]);
  130.         }
  131.         else
  132.         {
  133.             if(Index < NumBaudRates - 1)
  134.                 return(BaudRates[Index + 1]);
  135.             else
  136.                 return(BaudRates[Index]);
  137.         }
  138.     }
  139. }
  140.  
  141. BYTE __regargs
  142. SerialPanel(struct Configuration *Config,BYTE *Default)
  143. {
  144.     STATIC struct Hook IncrementerHook =
  145.     {
  146.         {NULL},
  147.         (HOOKFUNC)RateHookFunc
  148.     };
  149.  
  150.     struct LayoutHandle    *Handle;
  151.     BYTE             Cancel = FALSE;
  152.  
  153.     SaveConfig(Config,PrivateConfig);
  154.  
  155.     if(Handle = LT_CreateHandleTags(Window -> WScreen,
  156.         LH_LocaleHook,    &LocaleHook,
  157.     TAG_DONE))
  158.     {
  159.         struct Window    *PanelWindow;
  160.         LONG         Rate,Size,Quantum,Bits,StopBits,i;
  161.  
  162.         for(i = 0 ; i < NumBaudRates ; i++)
  163.         {
  164.             if(Config -> SerialConfig -> BaudRate == BaudRates[i])
  165.             {
  166.                 Rate = i;
  167.  
  168.                 break;
  169.             }
  170.         }
  171.  
  172.         for(i = 4 ; i < sizeof(Sizes) / sizeof(LONG) ; i++)
  173.         {
  174.             if(Config -> SerialConfig -> SerialBufferSize == Sizes[i])
  175.             {
  176.                 Size = i;
  177.  
  178.                 break;
  179.             }
  180.         }
  181.  
  182.         for(i = 0 ; i < sizeof(Sizes) / sizeof(LONG) ; i++)
  183.         {
  184.             if(Config -> SerialConfig -> Quantum == Sizes[i])
  185.             {
  186.                 Quantum = i;
  187.  
  188.                 break;
  189.             }
  190.         }
  191.  
  192.         if(Config -> SerialConfig -> HighSpeed)
  193.         {
  194.             Config -> SerialConfig -> BitsPerChar    = 8;
  195.             Config -> SerialConfig -> StopBits    = 1;
  196.             Config -> SerialConfig -> Parity    = PARITY_NONE;
  197.         }
  198.  
  199.         LT_New(Handle,
  200.             LA_Type,    VERTICAL_KIND,
  201.         TAG_DONE);
  202.         {
  203.             LT_New(Handle,
  204.                 LA_Type,    HORIZONTAL_KIND,
  205.                 LA_LabelID,    MSG_V36_0171,
  206.             TAG_DONE);
  207.             {
  208.                 LT_New(Handle,
  209. /*                    LA_LabelID,    MSG_V36_0171,*/
  210.                     LA_Type,    VERTICAL_KIND,
  211.                 TAG_DONE);
  212.                 {
  213. /*
  214.                     LT_New(Handle,
  215.                         LA_Type,        SLIDER_KIND,
  216.                         LA_LabelID,        MSG_SERIALPANEL_BAUD_RATE_GAD,
  217.                         LA_LONG,        &Rate,
  218.                         GTSL_Min,        0,
  219.                         GTSL_Max,        NumBaudRates - 1,
  220.                         GTSL_DispFunc,        ShowBaud,
  221.                         GTSL_LevelFormat,    LocaleBase ? "%7lD" : "%7ld",
  222.                     TAG_DONE);
  223. */
  224.  
  225.                     LT_New(Handle,
  226.                         LA_Type,        INTEGER_KIND,
  227.                         LA_LabelID,        MSG_SERIALPANEL_BAUD_RATE_GAD,
  228.                         LA_LONG,        &Config -> SerialConfig -> BaudRate,
  229.                         LA_ID,            GAD_BAUD,
  230.                         GTIN_MaxChars,        8,
  231.                         LAIN_Min,        0,
  232.                         LAIN_UseIncrementers,    TRUE,
  233.                         LAIN_IncrementerHook,    &IncrementerHook,
  234.                     TAG_DONE);
  235.  
  236.                     Bits = Config -> SerialConfig -> BitsPerChar - 7;
  237.  
  238.                     LT_New(Handle,
  239.                         LA_Type,        CYCLE_KIND,
  240.                         LA_ID,            GAD_DATABITS,
  241.                         LA_LabelID,        MSG_SERIALPANEL_BITS_PER_CHAR_GAD,
  242.                         LA_LONG,        &Bits,
  243.                         GA_Disabled,        Config -> SerialConfig -> HighSpeed,
  244.                         LACY_FirstLabel,    MSG_SERIALPANEL_SEVEN_BITS_TXT,
  245.                         LACY_LastLabel,        MSG_SERIALPANEL_EIGHT_BITS_TXT,
  246.                     TAG_DONE);
  247.  
  248.                     LT_New(Handle,
  249.                         LA_Type,        CYCLE_KIND,
  250.                         LA_ID,            GAD_PARITY,
  251.                         LA_LabelID,        MSG_SERIALPANEL_PARITY_GAD,
  252.                         LA_BYTE,        &Config -> SerialConfig -> Parity,
  253.                         GA_Disabled,        Config -> SerialConfig -> HighSpeed,
  254.                         LACY_FirstLabel,    MSG_SERIALPANEL_NO_PARITY_TXT,
  255.                         LACY_LastLabel,        MSG_SERIALPANEL_SPACE_TXT,
  256.                     TAG_DONE);
  257.  
  258.                     StopBits = Config -> SerialConfig -> StopBits - 1;
  259.  
  260.                     LT_New(Handle,
  261.                         LA_Type,        CYCLE_KIND,
  262.                         LA_ID,            GAD_STOPBITS,
  263.                         LA_LabelID,        MSG_SERIALPANEL_STOP_BITS_GAD,
  264.                         LA_LONG,        &StopBits,
  265.                         GA_Disabled,        Config -> SerialConfig -> HighSpeed,
  266.                         LACY_FirstLabel,    MSG_SERIALPANEL_ONE_BIT_TXT,
  267.                         LACY_LastLabel,        MSG_SERIALPANEL_TWO_BITS_TXT,
  268.                     TAG_DONE);
  269.  
  270.                     LT_New(Handle,
  271.                         LA_Type,        CYCLE_KIND,
  272.                         LA_LabelID,        MSG_SERIALPANEL_HANDSHAKING_GAD,
  273.                         LA_BYTE,        &Config -> SerialConfig -> HandshakingProtocol,
  274.                         LACY_FirstLabel,    MSG_SERIALPANEL_HANDSHAKING_NONE_TXT,
  275.                         LACY_LastLabel,        MSG_SERIALPANEL_HANDSHAKING_RTS_CTS_DSR_TXT,
  276.                     TAG_DONE);
  277.  
  278.                     LT_New(Handle,
  279.                         LA_Type,        CYCLE_KIND,
  280.                         LA_LabelID,        MSG_SERIALPANEL_DUPLEX_GAD,
  281.                         LA_BYTE,        &Config -> SerialConfig -> Duplex,
  282.                         LACY_FirstLabel,    MSG_SERIALPANEL_DUPLEX_FULL_TXT,
  283.                         LACY_LastLabel,        MSG_SERIALPANEL_DUPLEX_HALF_TXT,
  284.                     TAG_DONE);
  285.  
  286.                     LT_New(Handle,
  287.                         LA_Type,        SLIDER_KIND,
  288.                         LA_LabelID,        MSG_SERIALPANEL_BUFFER_SIZE_GAD,
  289.                         LA_LONG,        &Size,
  290.                         GTSL_Min,        4,
  291.                         GTSL_Max,        (sizeof(Sizes) / sizeof(LONG)) - 1,
  292.                         GTSL_DispFunc,        ShowSize,
  293.                         GTSL_LevelFormat,    LocaleBase ? "%7lD" : "%7ld",
  294.                     TAG_DONE);
  295.  
  296.                     LT_New(Handle,
  297.                         LA_Type,        INTEGER_KIND,
  298.                         LA_LabelID,        MSG_SERIALPANEL_BREAK_LENGTH_GAD,
  299.                         LA_LONG,        &Config -> SerialConfig -> BreakLength,
  300.                         GTIN_MaxChars,        8,
  301.                     TAG_DONE);
  302.  
  303.                     LT_EndGroup(Handle);
  304.                 }
  305.  
  306.                 LT_New(Handle,
  307. /*                    LA_LabelID,    MSG_V36_0176,*/
  308.                     LA_Type,    VERTICAL_KIND,
  309.                 TAG_DONE);
  310.                 {
  311.                     LT_New(Handle,
  312.                         LA_Type,        CHECKBOX_KIND,
  313.                         LA_LabelID,        MSG_SERIALPANEL_STRIP_BIT_8_GAD,
  314.                         LA_BYTE,        &Config -> SerialConfig -> StripBit8,
  315.                     TAG_DONE);
  316.  
  317.                     LT_New(Handle,
  318.                         LA_Type,        CHECKBOX_KIND,
  319.                         LA_LabelID,        MSG_SERIALPANEL_SHARED_ACCESS_GAD,
  320.                         LA_BYTE,        &Config -> SerialConfig -> Shared,
  321.                     TAG_DONE);
  322.  
  323.                     LT_New(Handle,
  324.                         LA_Type,        CHECKBOX_KIND,
  325.                         LA_LabelID,        MSG_SERIALPANEL_XON_XOFF_GAD,
  326.                         LA_BYTE,        &Config -> SerialConfig -> xONxOFF,
  327.                     TAG_DONE);
  328.  
  329.                     LT_New(Handle,
  330.                         LA_Type,        CHECKBOX_KIND,
  331.                         LA_LabelID,        MSG_SERIALPANEL_PASS_XON_XOFF_THROUGH_GAD,
  332.                         LA_BYTE,        &Config -> SerialConfig -> PassThrough,
  333.                     TAG_DONE);
  334.  
  335.                     LT_New(Handle,
  336.                         LA_Type,        CHECKBOX_KIND,
  337.                         LA_LabelID,        MSG_SERIALPANEL_CHECK_CARRIER_GAD,
  338.                         LA_BYTE,        &Config -> SerialConfig -> CheckCarrier,
  339.                     TAG_DONE);
  340.  
  341.                     LT_New(Handle,
  342.                         LA_Type,        CHECKBOX_KIND,
  343.                         LA_LabelID,        MSG_SERIALPANEL_HIGH_SPEED_MODE_GAD,
  344.                         LA_BYTE,        &Config -> SerialConfig -> HighSpeed,
  345.                         LA_ID,            GAD_HIGHSPEED,
  346.                     TAG_DONE);
  347.  
  348.                     LT_New(Handle,
  349.                         LA_Type,        CHECKBOX_KIND,
  350.                         LA_LabelID,        MSG_SERIALPANEL_USE_OWNDEVUNIT_TXT,
  351.                         LA_BYTE,        &Config -> SerialConfig -> UseOwnDevUnit,
  352.                         LA_ID,            GAD_USE_OWNDEVUNIT,
  353.                     TAG_DONE);
  354.  
  355.                     LT_New(Handle,
  356.                         LA_Type,        SLIDER_KIND,
  357.                         LA_LabelID,        MSG_SERIALPANEL_QUANTUM_GAD,
  358.                         LA_LONG,        &Quantum,
  359.                         LA_Chars,        6,
  360.                         GTSL_Min,        0,
  361.                         GTSL_Max,        (sizeof(Sizes) / sizeof(LONG)) - 1,
  362.                         GTSL_Level,        Quantum,
  363.                         GTSL_DispFunc,        ShowSize,
  364.                         GTSL_LevelFormat,    LocaleBase ? "%7lD" : "%7ld",
  365.                     TAG_DONE);
  366.  
  367.                     LT_EndGroup(Handle);
  368.                 }
  369.  
  370.                 LT_EndGroup(Handle);
  371.             }
  372.  
  373.             LT_New(Handle,
  374.                 LA_LabelID,    MSG_V36_0179,
  375.                 LA_Type,    VERTICAL_KIND,
  376.             TAG_DONE);
  377.             {
  378.                 LT_New(Handle,
  379.                     LA_Type,        STRING_KIND,
  380.                     LA_LabelID,        MSG_SERIALPANEL_SERIAL_DEVICE_GAD,
  381.                     LA_Chars,        20,
  382.                     LA_STRPTR,        Config -> SerialConfig -> SerialDevice,
  383.                     GTST_MaxChars,        255,
  384.                     LAST_Picker,        TRUE,
  385.                     LA_ID,            GAD_DEVICE,
  386.                 TAG_DONE);
  387.  
  388.                 LT_New(Handle,
  389.                     LA_Type,        INTEGER_KIND,
  390.                     LA_LabelID,        MSG_SERIALPANEL_DEVICE_UNIT_NUMBER_GAD,
  391.                     LA_LONG,        &Config -> SerialConfig -> UnitNumber,
  392.                     LA_ID,            GAD_UNIT,
  393.                     LAIN_UseIncrementers,    TRUE,
  394.                     GTIN_MaxChars,        8,
  395.                 TAG_DONE);
  396.  
  397.                 LT_EndGroup(Handle);
  398.             }
  399.  
  400.             LT_New(Handle,
  401.                 LA_Type,VERTICAL_KIND,
  402.             TAG_DONE);
  403.             {
  404.                 LT_New(Handle,
  405.                     LA_Type,    XBAR_KIND,
  406.                     LAXB_FullSize,    TRUE,
  407.                 TAG_DONE);
  408.  
  409.                 LT_EndGroup(Handle);
  410.             }
  411.  
  412.             LT_New(Handle,LA_Type,HORIZONTAL_KIND,
  413.                 LAGR_SameSize,    TRUE,
  414.                 LAGR_Spread,    TRUE,
  415.             TAG_DONE);
  416.             {
  417.                 LT_New(Handle,
  418.                     LA_Type,    BUTTON_KIND,
  419.                     LA_LabelID,    MSG_GLOBAL_USE_GAD,
  420.                     LA_ID,        GAD_USE,
  421.                     LABT_ReturnKey,    TRUE,
  422.                     LABT_ExtraFat,    TRUE,
  423.                 TAG_DONE);
  424.  
  425.                 if(Default)
  426.                 {
  427.                     LT_New(Handle,
  428.                         LA_Type,    BUTTON_KIND,
  429.                         LA_LabelID,    MSG_GLOBAL_DEFAULT_GAD,
  430.                         LA_ID,        GAD_DEFAULT,
  431.                         LABT_ExtraFat,    TRUE,
  432.                     TAG_DONE);
  433.                 }
  434.  
  435.                 LT_New(Handle,
  436.                     LA_Type,    BUTTON_KIND,
  437.                     LA_LabelID,    MSG_GLOBAL_CANCEL_GAD,
  438.                     LA_ID,        GAD_CANCEL,
  439.                     LABT_EscKey,    TRUE,
  440.                     LABT_ExtraFat,    TRUE,
  441.                 TAG_DONE);
  442.  
  443.                 LT_EndGroup(Handle);
  444.             }
  445.  
  446.             LT_EndGroup(Handle);
  447.         }
  448.  
  449.         if(PanelWindow = LT_Layout(Handle,LocaleString(MSG_SERIALPANEL_SERIAL_PREFERENCES_TXT),NULL,0,0,IDCMP_CLOSEWINDOW,0,
  450.             LAWN_HelpHook,        &GuideHook,
  451.             LAWN_Parent,        Window,
  452.             WA_DepthGadget,        TRUE,
  453.             WA_CloseGadget,        TRUE,
  454.             WA_DragBar,        TRUE,
  455.             WA_RMBTrap,        TRUE,
  456.             WA_Activate,        TRUE,
  457.         TAG_DONE))
  458.         {
  459.             UBYTE             DummyBuffer[MAX_FILENAME_LENGTH];
  460.             struct IntuiMessage    *Message;
  461.             BOOLEAN             Done = FALSE;
  462.             ULONG             MsgClass,
  463.                          MsgQualifier;
  464.             UWORD             MsgCode;
  465.             struct Gadget        *MsgGadget;
  466.  
  467.             GuideContext(CONTEXT_SERIAL);
  468.  
  469.             PushWindow(PanelWindow);
  470.  
  471.             LT_ShowWindow(Handle,TRUE);
  472.  
  473.             do
  474.             {
  475.                 if(Wait(PORTMASK(PanelWindow -> UserPort) | SIG_BREAK) & SIG_BREAK)
  476.                 {
  477.                     SaveConfig(PrivateConfig,Config);
  478.  
  479.                     break;
  480.                 }
  481.  
  482.                 while(Message = (struct IntuiMessage *)GT_GetIMsg(PanelWindow -> UserPort))
  483.                 {
  484.                     MsgClass    = Message -> Class;
  485.                     MsgQualifier    = Message -> Qualifier;
  486.                     MsgCode        = Message -> Code;
  487.                     MsgGadget    = (struct Gadget *)Message -> IAddress;
  488.  
  489.                     GT_ReplyIMsg(Message);
  490.  
  491.                     LT_HandleInput(Handle,MsgQualifier,&MsgClass,&MsgCode,&MsgGadget);
  492.  
  493.                     if(MsgClass == IDCMP_CLOSEWINDOW)
  494.                     {
  495.                         SaveConfig(PrivateConfig,Config);
  496.  
  497.                         Done = TRUE;
  498.                     }
  499.  
  500.                     if(MsgClass == IDCMP_GADGETUP)
  501.                     {
  502.                         switch(MsgGadget -> GadgetID)
  503.                         {
  504.                             case GAD_HIGHSPEED:
  505.  
  506.                                 if(MsgCode)
  507.                                 {
  508.                                     LT_SetAttributes(Handle,GAD_PARITY,
  509.                                         GA_Disabled,    TRUE,
  510.                                         GTCY_Active,    PARITY_NONE,
  511.                                     TAG_DONE);
  512.  
  513.                                     LT_SetAttributes(Handle,GAD_STOPBITS,
  514.                                         GA_Disabled,    TRUE,
  515.                                         GTCY_Active,    0,
  516.                                     TAG_DONE);
  517.  
  518.                                     LT_SetAttributes(Handle,GAD_DATABITS,
  519.                                         GA_Disabled,    TRUE,
  520.                                         GTCY_Active,    1,
  521.                                     TAG_DONE);
  522.                                 }
  523.                                 else
  524.                                 {
  525.                                     LT_SetAttributes(Handle,GAD_PARITY,
  526.                                         GA_Disabled,    FALSE,
  527.                                     TAG_DONE);
  528.  
  529.                                     LT_SetAttributes(Handle,GAD_STOPBITS,
  530.                                         GA_Disabled,    FALSE,
  531.                                     TAG_DONE);
  532.  
  533.                                     LT_SetAttributes(Handle,GAD_DATABITS,
  534.                                         GA_Disabled,    FALSE,
  535.                                     TAG_DONE);
  536.                                 }
  537.  
  538.                                 break;
  539.  
  540.                             case GAD_USE:
  541.  
  542. /*                                Config -> SerialConfig -> BaudRate = BaudRates[Rate];*/
  543.                                 Config -> SerialConfig -> SerialBufferSize = Sizes[Size];
  544.                                 Config -> SerialConfig -> Quantum = Sizes[Quantum];
  545.                                 Config -> SerialConfig -> BitsPerChar = Bits + 7;
  546.                                 Config -> SerialConfig -> StopBits = StopBits + 1;
  547.  
  548.                                 Done = TRUE;
  549.                                 break;
  550.  
  551.                             case GAD_CANCEL:
  552.  
  553.                                 SaveConfig(PrivateConfig,Config);
  554.  
  555.                                 Cancel = Done = TRUE;
  556.                                 break;
  557.  
  558.                             case GAD_DEFAULT:
  559.  
  560.                                 *Default = TRUE;
  561.  
  562.                                 Done = TRUE;
  563.                                 break;
  564.                         }
  565.                     }
  566.  
  567.                     if(MsgClass == IDCMP_IDCMPUPDATE && MsgGadget -> GadgetID == GAD_DEVICE)
  568.                     {
  569.                         LT_LockWindow(PanelWindow);
  570.  
  571.                         strcpy(DummyBuffer,(STRPTR)LT_GetAttributes(Handle,GAD_DEVICE));
  572.                         strcpy(SharedBuffer,DummyBuffer);
  573.  
  574.                         if(PickFile(PanelWindow,"Devs:","#?.device",LocaleString(MSG_SERIALPANEL_SELECT_DEVICE_TXT),SharedBuffer,NT_DEVICE))
  575.                         {
  576.                             if(Stricmp(DummyBuffer,SharedBuffer))
  577.                                 LT_SetAttributes(Handle,GAD_DEVICE,GTST_String,SharedBuffer,TAG_DONE);
  578.                         }
  579.  
  580.                         LT_UnlockWindow(PanelWindow);
  581.  
  582.                         LT_ShowWindow(Handle,TRUE);
  583.                     }
  584.                 }
  585.             }
  586.             while(!Done);
  587.  
  588.             PopWindow();
  589.         }
  590.  
  591.         LT_DeleteHandle(Handle);
  592.     }
  593.  
  594.     if(Default)
  595.         return((BYTE)(!Cancel));
  596.     else
  597.         return((BYTE)memcmp(PrivateConfig -> SerialConfig,Config -> SerialConfig,sizeof(struct SerialSettings)));
  598. }
  599.